package javase基础;

import java.util.Date;

import static java.lang.Math.*;

public class Computer封装 {
    /**
     * 封装Computer
     * public > protected > default > private
     * protected主要用在继承中
     * default什么都不写时的默认属性
     */
    /*
    private String cpu;
    private String memory;//内存
    public String screen;//屏幕
    String brand;//品牌，default属性
    public Computer封装(String cpu,String memory,String screen,String brand){
        this.cpu = cpu;
        this.memory = memory;
        this.screen = screen;
        this.brand = brand;
    }
    public void Boot(){
        System.out.println("开机");
    }
    public void PowerOff(){
        System.out.println("关机");
    }
    public void SurfInternet(){
        System.out.println("上网");
    }

    public static void main(String[] args) {
        Computer封装 p = new Computer封装("HW","i7","8G","13*14");
        System.out.println(p.brand);//default属性，只能在本包中类访问
        System.out.println(p.screen);//public属性，可以任何其他类访问
        System.out.println(p.cpu);//private属性，只能在Computer封装 类中访问，不能被其他类访问
    }

     */
    /*
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
        //得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }

     */
    /*
    public static void main(String[] args) {
        Date date = new Date();
        //得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }

     */
    /*
    public static void main(String[] args) {
        double x = 30;
        double y = 40;
        double result = sqrt(pow(x,2) + pow(y,2));
        System.out.println(result);
    }

     */

            /*
    //static修饰成员变量
    public String name;
    public String gender;
    public int age;
    public double score;
    public static String classRoom = "Bit306";

    public Computer封装(String li, int i, double v) {
    }

    public static void main(String[] args) {
        //静态成员变量可以直接通过类名访问
        System.out.println(Computer封装.classRoom);

        Computer封装 c1 = new Computer封装("li",12,30.8);
        Computer封装 c2 = new Computer封装("ds",1,2.3);
        Computer封装 c3 = new Computer封装("dcv",15,3.0);
        //也可以通过对象访问，但是classRoom是三个对象共享的
        System.out.println(c1.classRoom);
        System.out.println(c2.classRoom);
        System.out.println(c3.classRoom);
    }

             */


            /*
    //static修饰成员方法
            //通过类名.静态方法名（）方式调用
    private static String classRoom = "Bit306";

    public static String grtClassRoom(){
        return classRoom;
    }

    public static void main(String[] args) {
        System.out.println(Computer封装.grtClassRoom());
    }

             */

    //static成员变量初始化
    /**
     * 1.就地初始化
     * 2.静态代码块初始化
     */
/*
    //代码块：普通代码块，构造块，静态块，同步代码块
    //普通代码块：定义在方法中的代码块
    public static void main(String[] args) {
        {//直接使用{}定义，普通代码块
            int x = 10;
            System.out.println(x);
        }
        int x = 100;
        System.out.println(x);
    }

 */

            /*
    //构造代码块,也叫实例代码块
    //定义在类中的代码块，不加修饰符

    //实例成员变量
    private String name;
    private String gender;
    private int age;
    private double score;

    public Computer封装() {
        System.out.println("123");
    }

    //实例代码块
    {
        this.name = "bit";
        this.age = 12;
        this.gender = "man";
        System.out.println("4656");
    }

    public void show() {
        System.out.println(name + age + gender);
    }

    public static void main(String[] args) {
        Computer封装 stu = new Computer封装();
        stu.show();
    }

             */
/*
    //静态代码块：一般用于初始化静态成员变量
    private String name;
    private String gender;
    private int age;
    private static String classRoom;

    //实例代码块
    {
        this.name = "bit";
        this.age = 12;
        this.gender = "man";
        System.out.println("133");
    }
    //静态代码块
    static{
        classRoom = "bit306";
        System.out.println("456");
    }
    public Computer封装(){
        System.out.println("789");
    }

    public static void main(String[] args) {
        //静态代码块不管生成多少个对象，其只会执行一次
        //实例代码块只有在创建对象时才会执行
        Computer封装 s1 = new Computer封装();
        Computer封装 s2 = new Computer封装();
    }

 */
/*
    //内部类
    //可以将一个类定义在另一个类或者方法的内部，前者称为内部类，后者称为外部类
    public class OutClass{
        class innerClass{

        }
    }

 */
        /*
    //内部类的分类
    //未被static修饰-->实例内部类
    public class innerClass{}
    //被static修饰-->静态内部类
    static class innerClass2{}
    //局部内部类，几乎不用
    public void method(){
        class innerClass3{}
    }

         */

    //实例内部类：未被static修饰的成员内部类
    /**
     * 外部类中的任何成员都可以在实例内部类方法中直接访问
     * 实例内部类对象必须在由外部类对象前提下才能创建
     *
     */
    /*
    private int a;
    static int b;
    int c;
    public void methodA(){
        a=10;
        System.out.println(a);
    }
    public static void methodB(){
        System.out.println(b);
    }
    //实例内部类：未被static修饰
    class InnerClass{
        int c;
        public void methodInner(){
            //在实例内部类中可以直接访问外部类中：任意访问限定符修饰的成员
            a = 100;
            b = 200;
            methodA();
            methodB();
            //如果外部类和实例内部类中具有相同名称成员时，优先访问的是内部类自己的
            c = 300;
            System.out.println(c);
            //如果要访问外部类同名成员时，必须：外部类名称.this.同名成员名字
            Computer封装.this.c = 400;
            System.out.println(Computer封装.this.c);
        }
    }

    public static void main(String[] args) {
        //外部类，对象创建以及访问
        Computer封装 computer封装 = new Computer封装();
        System.out.println(computer封装.a);
        System.out.println(computer封装.b);
        System.out.println(computer封装.c);
        computer封装.methodA();
        computer封装.methodB();
        //要访问实例内部类中成员，必需幺创建实例内部类的对象
        //而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类

        //创建实例内部类对象
        Computer封装.InnerClass innerClass1 = new Computer封装().new InnerClass();

        //也可以
        Computer封装.InnerClass innerClass2 = computer封装.new InnerClass();
        innerClass2.methodInner();
    }

     */

    //静态内部类：被static修饰的内部成员类称为静态内部类
    /**
     * 在静态内部类中只能访问外部类中的静态成员
     * 创建静态内部类对象时，不需要先创建外部类对象
     *
     */
/*
    private int a;
    static int b;
    public void methodA(){
        a = 10;
        System.out.println(a);
    }
    public static void methodB(){
        System.out.println(b);
    }
    //静态内部类
    static class InnerClass{
        public void methodInner(){
            //在内部类中只能访问外部类的静态成员
            //a = 100;编译失败，因为a不是类成员变量
            b = 200;
            //methodA();编译失败，因为methodA()不是类成员方法
            methodB();
        }
    }

    public static void main(String[] args) {
        //静态内部类对象创建和成员访问
        Computer封装.InnerClass innerClass = new Computer封装.InnerClass();
        innerClass.methodInner();
    }

 */

    //局部内部类：定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用
    //只能在该方法体中使用，其他位置不能用


    //对象的打印
    //重写toString方法
    String name;
    String gender;
    int age;

    public Computer封装(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Computer封装{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                '}';
    }

    public static void main(String[] args) {
        Computer封装 computer封装 = new Computer封装("ds","nan",3);
        System.out.println(computer封装);
    }
}
